package com.eascs.web.o2o.web.util;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

import javax.servlet.http.HttpServletResponse;

import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPFile;
import org.apache.commons.net.ftp.FTPReply;

/**
 * O2O系统中行FTP工具类
 * 
 * @author Administrator
 */
public class FtpNetUtils {

	/**
	 * Description: 向FTP服务器上传文件
	 * 
	 * @param url
	 *            FTP服务器hostname
	 * @param port
	 *            FTP服务器端口
	 * @param username
	 *            FTP登录账号
	 * @param password
	 *            FTP登录密码
	 * @param path
	 *            FTP服务器保存目录
	 * @param filename
	 *            上传到FTP服务器上的文件名
	 * @param input
	 *            输入流
	 * @return 成功返回true，否则返回false
	 */
	public static boolean uploadFile(String url, // FTP服务器hostname
			int port, // FTP服务器端口
			String username, // FTP登录账号
			String password, // FTP登录密码
			String path, // FTP服务器保存目录
			String filename, // 上传到FTP服务器上的文件名
			InputStream input // 输入流
	) {
		boolean success = false;
		FTPClient ftp = new FTPClient();
		try {
			int reply;
			ftp.connect(url, port);// 连接FTP服务器
			// 如果采用默认端口，可以使用ftp.connect(url)的方式直接连接FTP服务器
			ftp.login(username, password);// 登录
			reply = ftp.getReplyCode();
			if (!FTPReply.isPositiveCompletion(reply)) {
				ftp.disconnect();
				return success;
			}
			filename = StringUtils.changeEncoding(filename, "utf-8", "iso-8859-1");
			FtpNetUtils.createDir(ftp, path);
			// ftp.changeWorkingDirectory(path);
			ftp.setFileType(FTPClient.BINARY_FILE_TYPE);
			ftp.setBufferSize(2048 * 4);
			ftp.storeFile(filename, input);

			// input.close();
			ftp.logout();
			success = true;
		} catch (IOException e) {
			System.out.println(e.getMessage());
			// e.printStackTrace();
		} finally {
			if (ftp.isConnected()) {
				try {
					ftp.disconnect();
				} catch (IOException ioe) {
				}
			}
		}
		return success;
	}

	/**
	 * @param url
	 * @param port
	 * @param username
	 * @param password
	 * @param remotePath
	 * @param fileName
	 * @param output
	 *            不会关闭输出流,由使用者关闭
	 * @return
	 */
	public static boolean downFile(String url, // FTP服务器hostname
			int port, // FTP服务器端口
			String username, // FTP登录账号
			String password, // FTP登录密码
			// String remotePath,//
			String fileName, // (包括FTP服务器上的相对路径)要下载的文件名
			OutputStream output) {
		boolean success = false;
		FTPClient ftp = new FTPClient();
		try {
			int reply;
			ftp.connect(url, port);
			// 如果采用默认端口，可以使用ftp.connect(url)的方式直接连接FTP服务器
			ftp.login(username, password);// 登录
			reply = ftp.getReplyCode();
			if (!FTPReply.isPositiveCompletion(reply)) {
				ftp.disconnect();
				return success;
			}
			ftp.setFileType(FTPClient.BINARY_FILE_TYPE);
			ftp.retrieveFile(fileName, output);
			ftp.logout();
			success = true;
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (ftp.isConnected()) {
				try {
					ftp.disconnect();
				} catch (IOException ioe) {
				}
			}
		}
		return success;
	}

	/**
	 * Description: 从FTP服务器下载文件
	 * 
	 * @param url
	 *            FTP服务器hostname
	 * @param port
	 *            FTP服务器端口
	 * @param username
	 *            FTP登录账号
	 * @param password
	 *            FTP登录密码
	 * @param remotePath
	 *            FTP服务器上的相对路径
	 * @param fileName
	 *            要下载的文件名
	 * @param localPath
	 *            下载后保存到本地的路径
	 * @return
	 */
	public static boolean downFile1(String url, // FTP服务器hostname
			int port, // FTP服务器端口
			String username, // FTP登录账号
			String password, // FTP登录密码
			String remotePath, // FTP服务器上的相对路径
			String fileName, // 要下载的文件名
			HttpServletResponse response) {
		boolean success = false;
		FTPClient ftp = new FTPClient();
		try {
			int reply;
			ftp.connect(url, port);
			// 如果采用默认端口，可以使用ftp.connect(url)的方式直接连接FTP服务器
			ftp.login(username, password);// 登录
			reply = ftp.getReplyCode();
			if (!FTPReply.isPositiveCompletion(reply)) {
				ftp.disconnect();
				return success;
			}
			// ftp.changeWorkingDirectory(remotePath);// 转移到FTP服务器目录
			// FTPFile[] fs = ftp.listFiles();
			// for (FTPFile ff : fs) {
			// if (ff.getName().equals(fileName)) {
			//// File localFile = new File(localPath + "/" + ff.getName());
			//// OutputStream is = new FileOutputStream(localFile);
			//
			// OutputStream output = response.getOutputStream();
			// ftp.retrieveFile(ff.getName(), output);
			// output.flush();
			// output.close();
			// }
			// }
			ftp.setFileType(FTPClient.BINARY_FILE_TYPE);
			OutputStream output = response.getOutputStream();

			ftp.retrieveFile(remotePath + fileName, output);
			output.flush();
			output.close();

			ftp.logout();
			success = true;
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (ftp.isConnected()) {
				try {
					ftp.disconnect();
				} catch (IOException ioe) {
				}
			}
		}
		return success;
	}

	/**
	 * 根据路径创建目录,并会把工作目录自动转换到最后子目录
	 * 
	 * @param ftpClient
	 * @param path
	 * @return
	 * @throws IOException
	 */
	private static boolean createDir(FTPClient ftpClient, String path) throws IOException {
		// System.out.println("crateDir: "+path);
		if (path == null || path == "" || ftpClient == null) {
			return false;
		}
		String[] paths = path.split("/");
		for (int i = 0; i < paths.length; i++) {
			FTPFile[] ffs = ftpClient.listFiles(paths[i]);
			boolean is = true;

			for (FTPFile ftpFile : ffs) {
				if (null != ftpFile) {
					if (ftpFile.getName() == paths[i]) {
						ftpClient.changeWorkingDirectory(paths[i]);
						is = false;
						break;
					}
				}
			}

			if (is) {
				ftpClient.makeDirectory(new String(paths[i].getBytes("UTF-8"), "iso-8859-1"));
				ftpClient.changeWorkingDirectory(paths[i]);
			}
		}
		return true;
	}

	/**
	 * 根据路径创建目录,并会把工作目录自动转换到最后子目录
	 * 
	 * @param ftpClient
	 * @param path
	 * @return
	 * @throws IOException
	 */
	public static boolean createDir1(FTPClient ftpClient, String remote) throws IOException {
		boolean status = true;
		String directory = remote.substring(0, remote.lastIndexOf("\\") + 1);
		if (!directory.equalsIgnoreCase("/") && !ftpClient.changeWorkingDirectory(new String(directory.getBytes("UTF-8"), "iso-8859-1"))) {
			// 如果远程目录不存在，则递归创建远程服务器目录
			int start = 0;
			int end = 0;
			if (directory.startsWith("/")) {
				start = 1;
			} else {
				start = 0;
			}
			end = directory.indexOf("/", start);
			while (true) {
				String subDirectory = new String(remote.substring(start, end).getBytes("UTF-8"), "iso-8859-1");
				if (!ftpClient.changeWorkingDirectory(subDirectory)) {
					if (ftpClient.makeDirectory(subDirectory)) {
						ftpClient.changeWorkingDirectory(subDirectory);
					} else {
						System.out.println("创建目录失败");
						return false;
					}
				}

				start = end + 1;
				end = directory.indexOf("/", start);

				// 检查所有目录是否创建完毕
				if (end <= start) {
					break;
				}
			}
		}
		return status;
	}

	public static boolean downloadFile(String url, // FTP服务器hostname
			int port, // FTP服务器端口
			String username, // FTP登录账号
			String password, // FTP登录密码,
			String remotePath, String fileName) {

		boolean success = false;
		try {

			FTPClient ftp = new FTPClient();

			ftp.connect(url, port);

			ftp.login(username, password);// 登录

			ftp.changeWorkingDirectory(remotePath);// 转移到FTP服务器目录
			FTPFile[] fs = ftp.listFiles();
			for (FTPFile ff : fs) {
				if (ff.getName().equals(fileName)) {
					/*
					 * File localFile = new File(localPath+"/"+ff.getName());
					 * OutputStream is = new FileOutputStream(localFile);
					 * ftp.retrieveFile(ff.getName(), is); is.close();
					 */
					System.out.println("FTPUtils.downloadFile()" + ff.getName());
				}
			}

		} catch (Exception e) {
			e.printStackTrace();
		}
		return success;
	}

	/**
	 * Description: 从FTP服务器下载文件
	 * 
	 * @param url
	 *            FTP服务器hostname
	 * @param port
	 *            FTP服务器端口
	 * @param username
	 *            FTP登录账号
	 * @param password
	 *            FTP登录密码
	 * @param remotePath
	 *            FTP服务器上的相对路径
	 * @param fileName
	 *            要下载的文件名
	 * @param localPath
	 *            下载后保存到本地的路径
	 * @return
	 */
	@SuppressWarnings("resource")
	public static boolean downFile(String url, // FTP服务器hostname
			int port, // FTP服务器端口
			String username, // FTP登录账号
			String password, // FTP登录密码
			String remotePath, // FTP服务器上的相对路径
			String fileName) {
		boolean success = false;
		FTPClient ftp = new FTPClient();
		try {
			int reply;
			ftp.connect(url, port);
			// 如果采用默认端口，可以使用ftp.connect(url)的方式直接连接FTP服务器
			ftp.login(username, password);// 登录
			reply = ftp.getReplyCode();
			if (!FTPReply.isPositiveCompletion(reply)) {
				ftp.disconnect();
				return success;
			}

			ftp.setFileType(FTPClient.BINARY_FILE_TYPE);
			ByteArrayOutputStream fos = new ByteArrayOutputStream();
			ftp.retrieveFile(remotePath + fileName, fos);
			ByteArrayInputStream in = new ByteArrayInputStream(fos.toByteArray());
			if (null != in) {
				System.out.println("FtpNetUtils.ftpAttachment()" + remotePath + fileName);
				// BufferedReader reader = new BufferedReader(new
				// InputStreamReader(in));
				// ftp.storeFile(newPath+fileName, in);
				byte[] data = new byte[1024 * 8];
				int len = 0;
				FileOutputStream fileOutputStream = null;
				fileOutputStream = new FileOutputStream("E:\\2015\\" + fileName);
				while ((len = in.read(data)) != -1) {
					fileOutputStream.write(data, 0, len);
				}
				fos.flush();
			}
			ftp.logout();
			success = true;
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (ftp.isConnected()) {
				try {
					ftp.disconnect();
				} catch (IOException ioe) {
				}
			}
		}
		return success;
	}

	/**
	 * Description: 从FTP服务器删除文件
	 * 
	 * @param url
	 *            FTP服务器hostname
	 * @param port
	 *            FTP服务器端口
	 * @param username
	 *            FTP登录账号
	 * @param password
	 *            FTP登录密码
	 * @param remotePath
	 *            FTP服务器上的相对路径
	 * @param fileName
	 *            要删除的文件名
	 * @param localPath
	 *            删除后保存到本地的路径
	 * @return
	 */
	public static boolean deleteFile(String url, int port, String username, String password, String filePathName) {
		boolean success = false;
		FTPClient ftp = new FTPClient();
		try {
			int reply;
			ftp.connect(url, port);
			// 如果采用默认端口，可以使用ftp.connect(url)的方式直接连接FTP服务器
			ftp.login(username, password);// 登录
			reply = ftp.getReplyCode();
			if (!FTPReply.isPositiveCompletion(reply)) {
				ftp.disconnect();
				return success;
			}
			ftp.setFileType(FTPClient.BINARY_FILE_TYPE);
			ftp.deleteFile(filePathName);
			ftp.logout();
			success = true;
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (ftp.isConnected()) {
				try {
					ftp.disconnect();
				} catch (IOException ioe) {
				}
			}
		}
		return success;
	}
}
